/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package org.colswe.testingProject.dao;

import java.util.Collection;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Query;
import org.colswe.testingProject.entity.SystemUser;

/**
 * La clase SystemDao es la clase que se encarga de hacer las operaciones CRUD
 * para la clase SystemUser.
 *
 * @author andres
 */
public class SystemUserDao {

    /**
     * EntityManagerGactory necesario para crear EntityManager para las
     * operaciones en la base de datos.
     */
    private EntityManagerFactory emf;

    /**
     * Constructor de la clase SystemUserDao.
     *
     * @param emf EntityManagerFactory necesario para la comunicación con la
     * base de datos
     */
    public SystemUserDao(EntityManagerFactory emf) {
        this.emf = emf;
    }

    /**
     * Función que permite la persistencia de un objeto en la base de datos.
     *
     * @param toCreate Objeto SystemUser que se va a persistir
     * @return Verdadero si la operación fue correcta, falso si no
     */
    public boolean create(SystemUser toCreate) {
        boolean result = true;
        EntityManager em = emf.createEntityManager();
        try {
            em.getTransaction().begin();
            em.persist(toCreate);
            em.getTransaction().commit();
        } catch (Exception ex) {
            result = false;
            System.err.println(ex.getMessage());
            ex.printStackTrace(System.err);
        } finally {
            if (em != null) {
                em.close();
            }
        }
        return result;
    }

    /**
     * Función que permite la lectura de un objeto en la base de datos.
     *
     * @param toRead SystemUser que se va leer de la base de datos
     * @return Una instancia de SystemUser, si el existe en la base de datos,
     * null en caso contrario
     */
    public SystemUser read(SystemUser toRead) {
        SystemUser systemUser;
        EntityManager em = emf.createEntityManager();
        try {
            em = emf.createEntityManager();
            Query query = em.createQuery("SELECT u FROM SystemUser "
                    + "AS u WHERE u.userName= :userParam");
            query.setParameter("userParam", toRead.getUserName());
            em.getTransaction().begin();
            systemUser = (SystemUser) query.getSingleResult();
            em.getTransaction().commit();
        } catch (Exception ex) {
            System.err.println(ex.getMessage());
            ex.printStackTrace(System.err);
            systemUser = null;
        } finally {
            if (em != null && em.isOpen()) {
                em.close();
            }
        }
        return systemUser;
    }

    /**
     * Función que permite la actualización de un objeto en la base de datos.
     *
     * @param toUpdate SysteUser que se va a actualizar
     * @return Verdadero si se hizo correctamente la operación, falso en caso
     * contrario
     */
    public boolean update(SystemUser toUpdate) {
        boolean result = true;
        SystemUser old;
        EntityManager em = emf.createEntityManager();
        try {
            old = read(toUpdate);
            if (old != null) {
                toUpdate.setId(old.getId());
                em.getTransaction().begin();
                em.merge(toUpdate);
                em.getTransaction().commit();
            } else {
                throw new Exception("The registry does not exist");
            }
        } catch (Exception ex) {
            System.out.println(ex.getMessage());
            ex.printStackTrace(System.err);
            result = false;
        } finally {
            if (em != null) {
                em.close();
            }
        }
        return result;
    }

    /**
     * Función que permite la eliminación de un objeto de la base de datos.
     *
     * @param toDelete SystemUser que se va a eliminar
     * @return Verdadero si se hizo correctamente la operación, falso en caso
     * contrario
     */
    public boolean delete(SystemUser toDelete) {
        boolean result = true;
        EntityManager em = emf.createEntityManager();
        try {
            toDelete = read(toDelete);
            if (toDelete != null) {
                em.getTransaction().begin();
                toDelete = em.getReference(SystemUser.class, toDelete.getId());
                em.remove(toDelete);
                em.getTransaction().commit();
            } else {
                throw new Exception("The registry does not exist");
            }
        } catch (Exception ex) {
            System.out.println(ex.getMessage());
            ex.printStackTrace(System.err);
            result = false;
        } finally {
            if (em != null) {
                em.close();
            }
        }
        return result;
    }

    /**
     * Función que permite la lectura de todos los objetos SystemUser.
     *
     * @return Collection con todos los SystemUser, null si se presenta algún
     * error
     */
    public Collection<SystemUser> readAll() {
        Collection<SystemUser> result;
        EntityManager em = emf.createEntityManager();
        try {
            em = emf.createEntityManager();
            Query query = em.createQuery("SELECT u FROM SystemUser AS u");
            em.getTransaction().begin();
            result = query.getResultList();
            em.getTransaction().commit();
        } catch (Exception ex) {
            System.err.println(ex.getMessage());
            ex.printStackTrace(System.err);
            result = null;
        } finally {
            if (em != null && em.isOpen()) {
                em.close();
            }
        }
        return result;
    }
}
